Walkthrough

Adds MPU6050 IMU support, exposes gravity in shared data, registers IMU driver and triggers per-node init under mutex, removes compile-time gyro guards in effects, adds I2C initialization and device scanning, and updates platformio dependencies.

Changes

Sequence Diagram

sequenceDiagram
    participant NM as NodeManager
    participant MD as ModuleDrivers
    participant IMU as IMUDriver
    participant I2C as I2C Bus
    participant SD as SharedData
    participant Effect as E_MoonLight

    NM->>MD: request node allocation (node.on = true)
    MD->>IMU: instantiate IMUDriver
    NM->>IMU: nodeClass->onUpdate(oldValue, nodeState)
    IMU->>I2C: init / probe MPU6050 (Wire)
    I2C-->>IMU: ACK / device bytes
    IMU->>IMU: DMP init & calibration
    loop every 20ms
        IMU->>I2C: read FIFO packet
        I2C-->>IMU: sensor packet
        IMU->>IMU: compute quaternion → gravity & euler
        IMU->>SD: update sharedData.gravity
    end
    Effect->>SD: read sharedData.gravity
    SD-->>Effect: gravity vector
    Effect->>Effect: apply gravity to rendering

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• Add node mutex  #103: introduces per-node mutex wrapping and mutex-guarded onUpdate/onLayout — closely related to NodeManager changes.
• prep71 #106: modifies ModuleState updatedItem/mutex/updatePending semantics — overlaps with per-node update/mutex interactions.
• v0.7.0 preparations #76: refactors driver registration and node-allocation flows — relates to IMU driver registration/allocation.

Poem

🐰
I woke to sensors, six axes bright,
Gravity tucked in shared-data light,
No guards to hide the gyro's glow,
I2C hummed and numbers flow,
MoonLight hops — the rabbit codes tonight.

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

@coderabbitai, the mcu6050 is not working, I wired the scanner/scl/gnd/vcc correctly. got the following logging, what is wrong?

[ 56027][D][NodeManager.h:262] onUpdate(): [💫] httpd (1524) MPU6050 driver ☸️ on: true (#2)
[ 56028][W][Wire.cpp:300] begin(): Bus already started in Master Mode.
[ 56028][I][D_MPU6050.h:42] initI2S(): [💫] httpd (1396) initI2S Wire begin success
m
0m
ALID_STATE

ransmit_receive failed: [259] ESP_ERR_INVALID_STATE
eturned Error 259
[ 56232][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 56233][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
transmit failed: [259] ESP_ERR_INVALID_STATE
[ 56334][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 56335][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 56335][I][D_MPU6050.h:77] onUpdate(): [💫] httpd (848) Testing device connections MPU6050 connection failed

#!/bin/bash

# Read the MPU6050 driver implementation
echo "=== D_MPU6050.h implementation ==="
cat src/MoonLight/Nodes/Drivers/D_MPU6050.h

echo -e "\n\n=== Searching for Wire.begin() calls ==="
rg -n "Wire\.begin" --type cpp --type-add 'cpp:*.{h,cpp,ino}'

echo -e "\n\n=== Searching for other I2C initializations ==="
rg -n "Wire\." --type cpp --type-add 'cpp:*.{h,cpp,ino}' -C 2 | head -100

@ewowi, I found the issue! The error "Bus already started in Master Mode" indicates that the I2C Wire interface is already initialized somewhere else (possibly by the ESP32 Arduino framework with default pins), and then your driver is trying to call Wire.begin(5, 6) again with different pins. This causes the ESP_ERR_INVALID_STATE errors.

The Problem

When Wire.begin() is called on an already-initialized I2C bus with different pin assignments, the ESP32 I2C driver gets into an invalid state and all subsequent I2C operations fail.

The Solution

You need to end the existing I2C bus before reinitializing it with your custom pins. Modify the initI2S() method in D_MPU6050.h:

bool initI2S() {
  // tbd: set pins in ui!!
  // allocatePin(21, "Pins", "I2S SDA");
  // allocatePin(22, "Pins", "I2S SCL");
  
  // End any existing I2C bus before reinitializing
  Wire.end();
  delay(10);  // Small delay to ensure bus is fully released
  
  bool success = Wire.begin(5, 6);
  EXT_LOGI(ML_TAG, "initI2S Wire begin %s", success ? "success" : "failure");
  return success;
}

The Wire.end() call will properly shut down the existing I2C bus, allowing you to reinitialize it with your custom pins (5 and 6).

Additional Checks

Also verify:

1. Pin 5 = SDA, Pin 6 = SCL - Make sure your physical wiring matches (some boards vary)
2. Pull-up resistors - Ensure you have 4.7kΩ pull-ups on both SDA and SCL lines (some MPU6050 modules have them built-in, some don't)
3. Power supply - Verify the MPU6050 is getting clean 3.3V power

Try the Wire.end() fix first - this should resolve the state error!

@coderabbitai, regarding

indicates that the I2C Wire interface is already initialized somewhere else (possibly by the ESP32 Arduino framework with default pins)
Could you check the repo where that could have been done?

Wire.end(); delay(10);

Improved it a bit but still errors, please investigate:

[ 69729][D][NodeManager.h:262] onUpdate(): [💫] httpd (1524) MPU6050 driver ☸️ on: true (#2)
[ 69740][I][esp32-hal-i2c-ng.c:112] i2cInit(): Initializing I2C Master: num=0 sda=5 scl=6 freq=100000
[ 69741][I][D_MPU6050.h:44] initI2S(): [💫] httpd (1284) initI2S Wire begin success
dNonStop returned Error 259
[ 69843][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 69844][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
m(): i2cWriteReadNonStop returned Error 259
TATE
m
m
_ERR_INVALID_STATE
259
ed

#!/bin/bash

echo "=== Searching for all Wire.begin() calls in the codebase ==="
rg -n "Wire\.begin" --type-add 'code:*.{h,cpp,ino,c}' --type code

echo -e "\n\n=== Searching for any I2C initialization patterns ==="
rg -n "I2C|i2c" --type-add 'code:*.{h,cpp,ino,c}' --type code -g '!*.json' -g '!*.md' | grep -i "init\|begin\|start" | head -50

echo -e "\n\n=== Looking for other driver files that might use I2C ==="
fd -e h -e cpp "D_.*\.h" src/

echo -e "\n\n=== Checking MPU6050 driver for address and initialization sequence ==="
cat src/MoonLight/Nodes/Drivers/D_MPU6050.h | grep -A 5 -B 5 "initialize\|setDeviceID\|0x68\|0x69"

echo -e "\n\n=== Searching for MPU6050 related configurations ==="
rg -n "MPU6050" --type-add 'code:*.{h,cpp,ino,c}' --type code -C 2

ESP32 I2C ESP_ERR_INVALID_STATE error 259 causes

@ewowi, Good news: I found no other Wire/I2C initialization in the entire codebase - only your MPU6050 driver initializes I2C.

The Real Problem

Based on the logs and research, the issue is likely that Wire.end() is causing the problem, not solving it. Here's why:

ESP_ERR_INVALID_STATE occurs when the I2C driver isn't properly installed or was deleted/deinitialized. When you call Wire.end(), it deletes the I2C driver. Then Wire.begin() succeeds in starting to initialize it, but the driver may not be in a fully usable state yet when mpu.testConnection() tries to communicate immediately after.

Solution: Remove Wire.end() and Add Proper Delay

Try this updated initI2S():

bool initI2S() {
  // tbd: set pins in ui!!
  // allocatePin(21, "Pins", "I2S SDA");
  // allocatePin(22, "Pins", "I2S SCL");
  
  // Don't call Wire.end() - it deletes the driver and causes INVALID_STATE
  bool success = Wire.begin(5, 6);
  EXT_LOGI(ML_TAG, "initI2S Wire begin %s", success ? "success" : "failure");
  
  if (success) {
    delay(100);  // Give I2C bus time to stabilize
  }
  
  return success;
}

Verify Hardware with I2C Scanner

Before testing again, let's verify the MPU6050 is actually present and at the correct address. Add this temporary diagnostic function:

void scanI2C() {
  EXT_LOGI(ML_TAG, "Scanning I2C bus...");
  byte count = 0;
  for (byte i = 1; i < 127; i++) {
    Wire.beginTransmission(i);
    if (Wire.endTransmission() == 0) {
      EXT_LOGI(ML_TAG, "Found I2C device at address 0x%02X", i);
      count++;
    }
  }
  EXT_LOGI(ML_TAG, "Found %d device(s)", count);
}

Call it in onUpdate() right after initI2S() succeeds:

if (initI2S()) {
  scanI2C();  // Diagnostic - remove after testing
  mpu.initialize();
  // ... rest of code

Hardware Checklist

The MPU6050 should appear at 0x68 or 0x69 (depending on AD0 pin). Verify:

1. Wiring:

   • GPIO 5 → SDA
   • GPIO 6 → SCL
   • GND → GND
   • 3.3V → VCC

2. Pull-up resistors: 4.7kΩ on both SDA and SCL (check if your module has them built-in)

3. Power: Clean 3.3V supply with stable ground

Let me know what addresses the scanner finds!

@coderabbitai, regarding

Let me know what addresses the scanner finds!

[ 18026][I][esp32-hal-i2c-ng.c:112] i2cInit(): Initializing I2C Master: num=0 sda=5 scl=6 freq=100000
[ 18027][I][D_MPU6050.h:44] initI2C(): [💫] httpd (1284) initI2C Wire begin success
[ 18128][I][D_MPU6050.h:54] scanI2C(): [💫] httpd (1284) Scanning I2C bus...
[ 24429][I][D_MPU6050.h:63] scanI2C(): [💫] httpd (1284) Found 0 device(s)
[ 24480][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 24481][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 24531][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 24532][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 24583][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 24584][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 24634][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 24635][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 24685][E][esp32-hal-i2c-ng.c:275] i2cWrite(): i2c_master_transmit failed: [259] ESP_ERR_INVALID_STATE
[ 24736][E][esp32-hal-i2c-ng.c:369] i2cWriteReadNonStop(): i2c_master_transmit_receive failed: [259] ESP_ERR_INVALID_STATE
[ 24737][E][Wire.cpp:520] requestFrom(): i2cWriteReadNonStop returned Error 259
[ 24737][I][D_MPU6050.h:99] onUpdate(): [💫] httpd (916) Testing device connections MPU6050 connection failed

@ewowi, The scanner found 0 devices, which means the MPU6050 isn't responding at all on the I2C bus. The root cause is likely GPIO pin selection. GPIO 5 is a strapping pin on ESP32, which must be high (1) during boot. Using strapping pins for I2C can cause initialization and communication issues.

Critical Issue: GPIO Pin Choice

ESP32 allows any GPIO pin to be configured as I2C SDA and SCL, but the default I2C pins for ESP32 with Arduino IDE are GPIO 22 (SCL) and GPIO 21 (SDA). These are the most reliable pins for I2C communication.

Immediate Solution: Use Standard I2C Pins

Change your initI2C() function to use the standard pins:

bool initI2C() {
  // Use standard ESP32 I2C pins
  // GPIO 21 = SDA, GPIO 22 = SCL
  bool success = Wire.begin(21, 22);
  EXT_LOGI(ML_TAG, "initI2C Wire begin %s", success ? "success" : "failure");
  
  if (success) {
    delay(100);  // Give I2C bus time to stabilize
  }
  
  return success;
}

Rewire your MPU6050:

• GPIO 21 → SDA
• GPIO 22 → SCL
• GND → GND
• 3.3V → VCC

Additional Troubleshooting

If the scanner still finds 0 devices after switching pins:

1. Check power with multimeter: Verify the MPU6050 VCC pin has 3.3V
2. Verify connections: Use a continuity tester to ensure wires are properly connected
3. Test MPU6050 on another device: Try connecting it to an Arduino/Teensy with a working I2C scanner
4. Check for shorts: Ensure SDA and SCL aren't shorted together or to GND/VCC
5. Use pull-up resistors of 3.3kΩ or 4.7kΩ if your MPU6050 module doesn't have them built-in

The fact that the scanner took 6+ seconds and then failed with ESP_ERR_INVALID_STATE suggests the I2C bus couldn't communicate at all — typically a sign of wrong pins, disconnected hardware, or a dead module.

Try the pin change first and let me know what the scanner finds!

@coderabbitai,
I use this board: https://www.seeedstudio.com/XIAO-ESP32S3-p-5627.html

Which has pin 5 and 6, please check their website and let me know if 5,6 is indeed right

Seeed XIAO ESP32S3 I2C pins GPIO pinout

@ewowi, Good news! Your pin configuration is correct ✅

The Seeed XIAO ESP32S3 uses GPIO 5 (SDA) and GPIO 6 (SCL) as the default I2C pins, so your code is using the right pins.

Since the pins are correct but the scanner found 0 devices, the issue is likely one of the following:

Hardware Issues to Check

1. Physical connections:

   • Double-check all 4 wires (SDA, SCL, VCC, GND) are firmly seated
   • Try different jumper wires (bad wires are common)

2. MPU6050 module power:

   • Verify the module's power LED is ON
   • Measure voltage at the MPU6050's VCC pin (should be 3.3V)

3. Pull-up resistors:

   • The XIAO ESP32S3 does NOT have built-in I2C pull-ups
   • Your MPU6050 module MUST have pull-up resistors (most do, but verify)
   • If missing, add external 4.7kΩ resistors from SDA→3.3V and SCL→3.3V

4. Test the MPU6050 module:

   • Try the module on another board/Arduino if possible
   • The module might be defective

Software Issue: Arduino-ESP32 Core Bug

The ESP_ERR_INVALID_STATE error you're seeing is a known issue with Arduino-ESP32 3.x's new I2C driver. There are reports of i2c_master_receive failing with error 259 (ESP_ERR_INVALID_STATE) in Arduino-ESP32 3.x.

Try adding a small delay after Wire.begin():

bool initI2C() {
  bool success = Wire.begin(5, 6);  // Correct pins for XIAO ESP32S3
  EXT_LOGI(ML_TAG, "initI2C Wire begin %s", success ? "success" : "failure");
  
  if (success) {
    delay(200);  // Longer delay for I2C bus stabilization
    Wire.setClock(100000);  // Explicitly set to 100kHz
  }
  
  return success;
}

What Arduino-ESP32 core version are you using? (Check platform.ini or Arduino IDE board manager)

@coderabbitai,

This is my mcu6050 board , do I need to short wire anything?

I am on arduino v3.3.5

@ewoudwijma, Great photo! I can see your GY-521 MPU6050 board clearly.

What I See in the Image

The Comment image shows a blue GY-521 MPU6050 breakout board with:

• ✅ Green LED is ON - This confirms the module is receiving power correctly
• Pin headers: VCC, GND, SCL, SDA, XDA, XCL, AD0, INT
• Surface mount resistors visible (pull-ups are built into this module)
• Wires connected to the header

The AD0 Pin - Important!

Yes, you should connect the AD0 pin! Here's why:

The AD0 pin controls the I2C address:

• AD0 = GND (or floating) → Address 0x68 (default)
• AD0 = VCC → Address 0x69

Right now, your AD0 pin appears to be floating (not connected), which can cause unreliable I2C communication.

Solution: Connect the AD0 pin to GND for the standard 0x68 address.

Arduino-ESP32 3.0.5 I2C Issues

You're on Arduino-ESP32 3.0.5, which has known I2C bugs causing ESP_ERR_INVALID_STATE errors. This is likely contributing to your problem.

Updated Code to Try

Update your initI2C() and onUpdate() methods:

bool initI2C() {
  bool success = Wire.begin(5, 6);  // XIAO ESP32S3 I2C pins
  EXT_LOGI(ML_TAG, "initI2C Wire begin %s", success ? "success" : "failure");
  
  if (success) {
    Wire.setClock(50000);  // Lower clock speed to 50kHz for stability
    delay(200);  // Longer stabilization delay
  }
  
  return success;
}

void onUpdate(const Char<20>& oldValue, const JsonObject& control) {
  EXT_LOGI(ML_TAG, "onUpdate %s", oldValue.charArr);
  if (control["n"].as<Char<20>>() == "on" && nodeState[control["n"].as<Char<20>>()].as<bool>()) {
    if (initI2C()) {
      scanI2C();  // Keep the scanner for now
      
      // Explicitly set MPU6050 address to 0x68
      mpu.setAddr(MPU6050_ADDRESS_AD0_LOW);  // or just use default
      mpu.initialize();
      
      delay(100);
      
      if (mpu.testConnection()) {
        EXT_LOGI(ML_TAG, "MPU6050 connection successful at address 0x68");
        // ... rest of DMP setup
      } else {
        EXT_LOGI(ML_TAG, "MPU6050 connection failed - check AD0 wiring");
      }
    }
  }
}

Wiring Checklist

XIAO ESP32S3 → MPU6050:

• GPIO 5 → SDA
• GPIO 6 → SCL
• 3.3V → VCC
• GND → GND
• GND → AD0 ← Add this connection!

Next Steps

1. Connect AD0 to GND
2. Lower I2C clock to 50kHz (more stable with ESP32 3.x)
3. Run the scanner again and let me know if it finds the device at 0x68

If it still doesn't work after grounding AD0, we may need to try Arduino-ESP32 v2.x or use a workaround for the 3.x I2C driver bug.

Let me know what the scanner shows after connecting AD0!

@coderabbitai,
can you do a thorough review of D_IMU.h and ModuleIO.h based on the changes in this PR. Especially focus on the decision to move the Wire code into ModuleIO.h making it a generic solution for all I2C devices. Is this the right approach. Also include a recommendation for default SDA/SCL pins for all supported ESP32 MCU's. Include follow up recommendations, including:

• The i2cBus control in ModuleIO.h now only shows an address, can we also add the name of the device? Should the IMU driver node tell that to the IO module? How do we know which address belongs to which module? Can the IMU module query for this in the IMU board
• Als add a proposal how to add support for the BMI160 IMU. We now use ElectronicCats/MPU6050 (see platformio.ini) for MPU650 support, do we need another library for the BMI160 - and for each future supported IMU? would be nice if there is one generic library for all IMU boards

Also make a recommendation how to do the same with SPI (generic in Module IO, other modules can use it).

#!/bin/bash

echo "=== Reading D_IMU.h ==="
cat src/MoonLight/Nodes/Drivers/D_IMU.h

echo -e "\n\n=== Reading ModuleIO.h ==="
cat src/MoonBase/Modules/ModuleIO.h

echo -e "\n\n=== Reading platformio.ini to see library dependencies ==="
cat platformio.ini | grep -A 20 "lib_deps"

echo -e "\n\n=== Checking for other I2C device drivers ==="
fd -e h "D_.*\.h" src/MoonLight/Nodes/Drivers/ -x echo "File: {}" \; -x head -30 {}

echo -e "\n\n=== Looking for ESP32 board definitions and pin configurations ==="
rg -n "ESP32|ARDUINO_" platformio.ini

echo -e "\n\n=== Searching for existing SPI usage in the codebase ==="
rg -n "SPI\.|#include.*SPI\.h" --type cpp --type-add 'cpp:*.{h,cpp}' -C 2

ESP32 ESP32-S2 ESP32-S3 ESP32-C3 ESP32-C6 ESP32-P4 default I2C pins GPIO

BMI160 Arduino ESP32 library IMU accelerometer gyroscope

`#include` <Wire.h>
`#include` <BMI160Gen.h>

const int i2c_addr = 0x68;

void setup() {
  Serial.begin(115200);
  Wire.begin(); // (On ESP32 you can also pass SDA,SCL pins if needed)
  BMI160.begin(BMI160GenClass::I2C_MODE, i2c_addr);  // shown in repo example [1]
}

void loop() {
  int gx, gy, gz;
  BMI160.readGyro(gx, gy, gz); // shown in repo example [1]
  Serial.printf("g: %d %d %d\n", gx, gy, gz);
  delay(200);
}

Arduino unified IMU library MPU6050 BMI160 LSM6DS3 multi-sensor support

@ewowi, I've completed a thorough analysis of the I2C centralization approach, researched ESP32 pin defaults, and explored BMI160 and generic IMU library options. Here's my comprehensive review:

✅ Architectural Review: I2C Centralization in ModuleIO.h

Is the centralized approach correct?

Yes, this is an excellent architectural decision! The centralization of I2C in ModuleIO.h provides:

1. ✅ Single Source of Truth: One place manages Wire initialization, pin configuration, and bus state
2. ✅ Prevents conflicts: Avoids multiple drivers calling Wire.begin() with different pins
3. ✅ Runtime reconfiguration: Pin changes trigger automatic Wire reinitialization
4. ✅ Bus discovery: Centralized updateDevices() scans all I2C devices once
5. ✅ Frequency control: Single i2cFreq parameter affects all I2C devices

Current Implementation Quality

ModuleIO.h I2C Management:

• ✅ Pin reading from UI configuration (pin_I2C_SDA, pin_I2C_SCL)
• ✅ Wire.end() before reinit to clean up previous state
• ✅ Frequency configuration with Wire.setClock()
• ✅ Device scanning with updateDevices()
• ⚠️ Issue: i2cBus only shows addresses, not device names

D_IMU.h Integration:

• ✅ Removed I2C initialization logic (no longer calls Wire.begin)
• ✅ Relies on Module IO for bus setup
• ⚠️ Issue: bool i2cInited = true; // todo: check in moduleIO if successfull - hardcoded, should actually check ModuleIO state

📌 Recommendation 1: Default I2C Pins for All ESP32 Variants

Based on Arduino-ESP32 platform defaults, update the default pin configuration in ModuleIO.h:

// In setBoardPresetDefaults() for board_none (default case):
`#ifdef` CONFIG_IDF_TARGET_ESP32
  pinAssigner.assignPin(21, pin_I2C_SDA);   // ESP32 classic
  pinAssigner.assignPin(22, pin_I2C_SCL);
`#elif` defined(CONFIG_IDF_TARGET_ESP32S2)
  pinAssigner.assignPin(8, pin_I2C_SDA);    // ESP32-S2
  pinAssigner.assignPin(9, pin_I2C_SCL);
`#elif` defined(CONFIG_IDF_TARGET_ESP32S3)
  pinAssigner.assignPin(8, pin_I2C_SDA);    // ESP32-S3
  pinAssigner.assignPin(9, pin_I2C_SCL);
`#elif` defined(CONFIG_IDF_TARGET_ESP32C3)
  pinAssigner.assignPin(8, pin_I2C_SDA);    // ESP32-C3
  pinAssigner.assignPin(9, pin_I2C_SCL);
`#elif` defined(CONFIG_IDF_TARGET_ESP32C6)
  pinAssigner.assignPin(23, pin_I2C_SDA);   // ESP32-C6
  pinAssigner.assignPin(22, pin_I2C_SCL);
`#elif` defined(CONFIG_IDF_TARGET_ESP32P4)
  pinAssigner.assignPin(7, pin_I2C_SDA);    // ESP32-P4 (common board default)
  pinAssigner.assignPin(8, pin_I2C_SCL);
`#else`
  pinAssigner.assignPin(21, pin_I2C_SDA);   // Fallback
  pinAssigner.assignPin(22, pin_I2C_SCL);
`#endif`

Note: Your current code already handles ESP32 vs others, but could be more explicit for C6 and P4.

📌 Recommendation 2: Device Naming Strategy for i2cBus

Problem: i2cBus control only shows numeric addresses (e.g., 0x68), not device names.

Solution: Implement a device identification registry

Step 1: Add device name field to i2cBus control

In ModuleIO.h:

control = addControl(controls, "i2cBus", "rows");
control["crud"] = "r";
rows = control["n"].to<JsonArray>();
{
  addControl(rows, "address", "number", 0, 255, true);  // ro
  addControl(rows, "name", "text", 0, 32, true);        // ro - NEW
}

Step 2: Create I2C device registry in ModuleIO

// In ModuleIO.h private section:
struct I2CDeviceInfo {
  uint8_t address;
  const char* name;
  Node* owner;  // Which node claimed this device
};
std::vector<I2CDeviceInfo> i2cDeviceRegistry;

public:
// Allow drivers to register their I2C devices
void registerI2CDevice(uint8_t address, const char* name, Node* owner) {
  for (auto& dev : i2cDeviceRegistry) {
    if (dev.address == address) {
      dev.name = name;
      dev.owner = owner;
      return;
    }
  }
  i2cDeviceRegistry.push_back({address, name, owner});
}

Step 3: Update updateDevices() to use registry

void updateDevices() {
  JsonDocument doc;
  doc["i2cBus"].to<JsonArray>();
  JsonObject newState = doc.as<JsonObject>();

  EXT_LOGI(ML_TAG, "Scanning I2C bus...");
  byte count = 0;
  for (byte i = 1; i < 127; i++) {
    Wire.beginTransmission(i);
    if (Wire.endTransmission() == 0) {
      JsonObject i2cDevice = newState["i2cBus"].as<JsonArray>().add<JsonObject>();
      i2cDevice["address"] = i;
      
      // Look up device name in registry
      const char* deviceName = "Unknown";
      for (const auto& dev : i2cDeviceRegistry) {
        if (dev.address == i) {
          deviceName = dev.name;
          break;
        }
      }
      i2cDevice["name"] = deviceName;
      
      EXT_LOGI(ML_TAG, "Found I2C device at address 0x%02X: %s", i, deviceName);
      count++;
    }
  }
  EXT_LOGI(ML_TAG, "Found %d device(s)", count);
  
  doc["i2cFreq"] = Wire.getClock() / 1000;
  update(newState, ModuleState::update, _moduleName);
}

Step 4: IMU driver registers itself

In D_IMU.h onUpdate():

if (control["on"] == true) {
  bool i2cInited = true;  // TODO: get from ModuleIO
  if (i2cInited) {
    if (board == 0) {  // MPU6050
      // Register this device with Module IO
      ModuleIO* io = modules->getModuleOfClass<ModuleIO>();
      if (io) {
        io->registerI2CDevice(0x68, "MPU6050", this);  // or 0x69 if AD0 high
      }
      
      mpu.initialize();
      // ... rest of code
    }
  }
}

Alternative Simpler Approach: Known I2C address database in ModuleIO:

const char* getDeviceNameByAddress(uint8_t addr) {
  switch(addr) {
    case 0x68: return "MPU6050/MPU9250";  // Could be either
    case 0x69: return "MPU6050/MPU9250 (AD0=HIGH)";
    case 0x76: return "BME280/BMP280";
    case 0x77: return "BME280/BMP280 (ALT)";
    case 0x3C: return "OLED SSD1306";
    case 0x3D: return "OLED SSD1306 (ALT)";
    case 0x40: return "PCA9685/INA219";
    // ... add more as needed
    default: return "Unknown";
  }
}

This is simpler but less accurate (address collisions between different chips). I recommend the registry approach for accuracy.

📌 Recommendation 3: BMI160 IMU Support

Library Recommendation

Use hanyazou/BMI160-Arduino (BMI160Gen.h API) - supports both I2C and SPI with simple API.

Why this library:

• ✅ I2C and SPI support
• ✅ I2C addresses: 0x68 (SDO=GND) or 0x69 (SDO=VCC)
• ✅ Similar API structure to MPU6050 libraries
• ✅ Actively maintained

Add to platformio.ini:

lib_deps = 
  ElectronicCats/MPU6050 @ 1.3.0 ; for MPU6050
  hanyazou/BMI160-Arduino @ ^1.0.0 ; for BMI160

Implementation in D_IMU.h

`#if` FT_MOONLIGHT

`#include` <MPU6050_6Axis_MotionApps20.h>
`#include` <BMI160Gen.h>  // NEW

class IMUDriver : public Node {
  // ... existing code ...
  
  void onUpdate(const Char<20>& oldValue, const JsonObject& control) override {
    if (!control["on"].isNull()) {
      if (control["on"] == true) {
        bool i2cInited = true;  // TODO: check ModuleIO
        if (i2cInited) {
          if (board == 0) {  // MPU6050
            // Register with Module IO
            ModuleIO* io = modules->getModuleOfClass<ModuleIO>();
            if (io) io->registerI2CDevice(0x68, "MPU6050", this);
            
            mpu.initialize();
            // ... existing MPU6050 code ...
            
          } else if (board == 1) {  // BMI160 - NEW
            // Register with Module IO
            ModuleIO* io = modules->getModuleOfClass<ModuleIO>();
            if (io) io->registerI2CDevice(0x68, "BMI160", this);
            
            BMI160.begin(BMI160GenClass::I2C_MODE, 0x68);
            
            if (BMI160.getDeviceID() == 0xD1) {  // BMI160 device ID
              EXT_LOGI(ML_TAG, "BMI160 connection successful");
              motionTrackingReady = true;
            } else {
              EXT_LOGW(ML_TAG, "BMI160 connection failed");
            }
          }
        }
      }
    }
  }
  
  void loop20ms() override {
    if (!motionTrackingReady) return;
    
    if (board == 0) {  // MPU6050
      // ... existing MPU6050 loop code ...
      
    } else if (board == 1) {  // BMI160 - NEW
      int gx, gy, gz, ax, ay, az;
      BMI160.readGyro(gx, gy, gz);
      BMI160.readAccelerometer(ax, ay, az);
      
      // Convert raw values to degrees (BMI160 gyro: 16.4 LSB/°/s at ±2000°/s range)
      gyro.x = gx / 16.4f;
      gyro.y = gy / 16.4f;
      gyro.z = gz / 16.4f;
      
      // Convert raw accel values (BMI160 accel: 16384 LSB/g at ±2g range)
      accell.x = ax;
      accell.y = ay;
      accell.z = az;
      
      // Calculate gravity vector from accelerometer
      float norm = sqrt(ax*ax + ay*ay + az*az);
      if (norm > 0) {
        sharedData.gravity.x = (ax / norm) * INT16_MAX;
        sharedData.gravity.y = (ay / norm) * INT16_MAX;
        sharedData.gravity.z = (az / norm) * INT16_MAX;
      }
    }
  }
  
 private:
  MPU6050 mpu;
  // BMI160 is accessed via static BMI160 object from library
};

`#endif`

Note: BMI160 uses I2C address 0x68 when SDO is grounded, same as MPU6050, so they can't coexist on the same bus without address changes.

📌 Recommendation 4: Generic IMU Library Strategy

Reality Check

Adafruit Unified Sensor is the closest to a unified Arduino IMU API, but BMI160 doesn't have Adafruit Unified Sensor support.

Recommended Approach: Internal Abstraction Layer

Don't try to use a single external library - instead, create your own thin abstraction:

// In D_IMU.h - add this interface
struct IMUSensorData {
  Coord3D gyro;       // degrees/sec
  Coord3D accell;     // raw or m/s²
  Coord3D gravity;    // normalized
  bool valid;
};

class IMUDriver : public Node {
  // ... existing code ...
  
private:
  // Unified read method
  IMUSensorData readSensor() {
    IMUSensorData data = {};
    
    if (board == 0) {  // MPU6050
      if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) {
        mpu.dmpGetQuaternion(&q, fifoBuffer);
        mpu.dmpGetGravity(&gravity, &q);
        mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
        
        data.gyro.x = ypr[1] * 180 / M_PI;
        data.gyro.y = ypr[0] * 180 / M_PI;
        data.gyro.z = ypr[2] * 180 / M_PI;
        
        mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
        data.accell.x = aaReal.x;
        data.accell.y = aaReal.y;
        data.accell.z = aaReal.z;
        
        data.gravity.x = gravity.x * INT16_MAX;
        data.gravity.y = gravity.y * INT16_MAX;
        data.gravity.z = gravity.z * INT16_MAX;
        data.valid = true;
      }
      
    } else if (board == 1) {  // BMI160
      int gx, gy, gz, ax, ay, az;
      BMI160.readGyro(gx, gy, gz);
      BMI160.readAccelerometer(ax, ay, az);
      
      data.gyro.x = gx / 16.4f;
      data.gyro.y = gy / 16.4f;
      data.gyro.z = gz / 16.4f;
      
      data.accell.x = ax;
      data.accell.y = ay;
      data.accell.z = az;
      
      float norm = sqrt(ax*ax + ay*ay + az*az);
      if (norm > 0) {
        data.gravity.x = (ax / norm) * INT16_MAX;
        data.gravity.y = (ay / norm) * INT16_MAX;
        data.gravity.z = (az / norm) * INT16_MAX;
      }
      data.valid = true;
    }
    
    return data;
  }
  
public:
  void loop20ms() override {
    if (!motionTrackingReady) return;
    
    IMUSensorData data = readSensor();
    if (data.valid) {
      gyro = data.gyro;
      accell = data.accell;
      sharedData.gravity = data.gravity;
      EXT_LOGD(ML_TAG, "Gyro: %f %f %f", gyro.x, gyro.y, gyro.z);
    }
  }
};

Benefits:

• ✅ Single loop20ms() code path
• ✅ Easy to add new IMU chips (just add another else if in readSensor())
• ✅ No dependency on unified external library
• ✅ Keep using best-in-class chip-specific libraries

Future IMUs to add:

• LSM6DS3 / LSM6DSO (common on newer boards)
• ICM-20948 (9-axis with magnetometer)
• BNO055/BNO085 (fusion-ready IMUs)

📌 Recommendation 5: SPI Centralization (Similar to I2C)

Current State

• ✅ SPI pin types defined in ModuleIO (pin_SPI_SCK, pin_SPI_MISO, pin_SPI_MOSI)
• ⚠️ SPI.begin() called in EthernetSettingsService.cpp (not centralized)

Proposed Changes

1. Add SPI management to ModuleIO.h:

// In setupDefinition():
addControl(controls, "spiFreq", "number", 0, 80000, false, "kHz");

control = addControl(controls, "spiBus", "rows");
control["crud"] = "r";
rows = control["n"].to<JsonArray>();
{
  addControl(rows, "cs", "number", 0, SOC_GPIO_PIN_COUNT-1, true);  // ro
  addControl(rows, "name", "text", 0, 32, true);                    // ro
}

// Private members:
uint8_t pinSPISCK = UINT8_MAX;
uint8_t pinSPIMISO = UINT8_MAX;
uint8_t pinSPIMOSI = UINT8_MAX;
std::vector<SPIDeviceInfo> spiDeviceRegistry;

struct SPIDeviceInfo {
  uint8_t csPin;
  const char* name;
  Node* owner;
};

// Public methods:
void registerSPIDevice(uint8_t csPin, const char* name, Node* owner);
bool isSPIInitialized() const { return pinSPISCK != UINT8_MAX && pinSPIMISO != UINT8_MAX && pinSPIMOSI != UINT8_MAX; }

2. Initialize SPI in readPins():

void readPins() {
  // ... existing I2C code ...
  
  // SPI pin detection
  for (JsonObject pinObject : _state.data["pins"].as<JsonArray>()) {
    uint8_t usage = pinObject["usage"];
    if (usage == pin_SPI_SCK) {
      pinSPISCK = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "SPISCK found %d", pinSPISCK);
    }
    if (usage == pin_SPI_MISO) {
      pinSPIMISO = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "SPIMISO found %d", pinSPIMISO);
    }
    if (usage == pin_SPI_MOSI) {
      pinSPIMOSI = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "SPIMOSI found %d", pinSPIMOSI);
    }
  }
  
  if (pinSPISCK != UINT8_MAX && pinSPIMISO != UINT8_MAX && pinSPIMOSI != UINT8_MAX) {
    SPI.end();  // Clean up any previous SPI initialization
    SPI.begin(pinSPISCK, pinSPIMISO, pinSPIMOSI);
    uint16_t frequency = _state.data["spiFreq"];
    if (frequency > 0) {
      // SPI frequency is set per-transaction, not globally like I2C
      EXT_LOGI(ML_TAG, "SPI bus initialized: sck:%d miso:%d mosi:%d", pinSPISCK, pinSPIMISO, pinSPIMOSI);
    }
  }
}

3. Update EthernetSettingsService to use ModuleIO's SPI:

// In EthernetSettingsService.cpp, replace SPI.begin() with:
ModuleIO* io = /* get ModuleIO reference */;
if (io && io->isSPIInitialized()) {
  // SPI already initialized by ModuleIO, just use it
  ETH.begin(v_ETH_PHY_TYPE, v_ETH_PHY_ADDR, v_ETH_PHY_CS, v_ETH_PHY_IRQ, v_ETH_PHY_RST, SPI);
} else {
  EXT_LOGW("Ethernet", "SPI not initialized by ModuleIO");
}

Benefits:

• ✅ Consistent architecture (I2C and SPI both in ModuleIO)
• ✅ Single source of truth for bus configuration
• ✅ Easy to add SPI-based drivers (displays, SD cards, etc.)
• ✅ Prevents pin conflicts

📋 Summary of Follow-up Actions

High Priority:

1. ✅ Fix i2cInited check in D_IMU.h - currently hardcoded to true
2. ✅ Add device naming to i2cBus - implement registry approach
3. ✅ Update ESP32-C6 and ESP32-P4 default pins - explicit per-variant defaults
4. ✅ Add BMI160 support - use hanyazou/BMI160-Arduino library

Medium Priority:

5. ✅ Create internal IMU abstraction - unified readSensor() method
6. ✅ Centralize SPI in ModuleIO - mirror I2C architecture
7. ✅ Document I2C/SPI device registration - for future driver developers

Low Priority:

8. Add more IMU chips (LSM6DS3, ICM-20948, BNO055)
9. Add SPI device scanning (enumerate CS pins with known devices)
10. Add I2C pull-up resistor strength configuration

Would you like me to generate code for any specific recommendation, or shall I create a GitHub issue with this analysis as a follow-up task?

Learnt from: ewowi
Repo: MoonModules/MoonLight PR: 0
File: :0-0
Timestamp: 2026-01-26T14:59:22.091Z
Learning: In MoonModules/MoonLight PR `#114`: ModuleDevices deadlock caused by: (1) StatefulService.h line 204-205 bug - after 500ms mutex timeout, continues WITHOUT acquiring mutex, causing race conditions and JSON corruption. (2) receiveUDP() while-loop processes own UDP broadcasts via loopback, creating circular call chain: sendUDP→broadcast→receiveUDP→updateDevices→update→handlers→sendUDP. (3) updateDevices() holds _accessMutex during expensive sort/JSON operations with 15 devices, can exceed 500ms with nested calls. Solution: Fix StatefulService to wait forever or reboot on timeout; skip own broadcasts by checking message.name == ownHostname; optimize updateDevices to sort outside mutex.

@coderabbitai, I also want to add my-sr602 pir and digital microphones like the ics43432/4 or inmp441

How to add these, generic solution like for i2c and spi needed ?

And do i2s microphones interfere with i2s FastLED drivers ?

#!/bin/bash

echo "=== Check current I2S usage in codebase ==="
rg -n "I2S|i2s" --type-add 'code:*.{h,cpp,ino}' --type code -g '!*.json' -g '!*.md' -C 2

echo -e "\n\n=== Check for PIR sensor mentions ==="
rg -n "PIR|pir|SR602|motion" --type-add 'code:*.{h,cpp,ino}' --type code -C 2

echo -e "\n\n=== Check FastLED RMT configuration ==="
rg -n "FASTLED_RMT|RMT|FastLED" --type-add 'code:*.{h,cpp,ino}' --type code -C 2

echo -e "\n\n=== Check platformio.ini for build flags ==="
cat platformio.ini | grep -A 30 "build_flags"

ESP32 I2S microphone Arduino library INMP441 ICS43432

`#include` <I2S.h>

void setup() {
  // bclk, ws(lrclk), dout, din, mclk
  I2S.setPins(26, 25, -1, 32, -1);
  I2S.begin(I2S_MODE_STD, 16000, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO);
}

void loop() {
  int32_t sample = I2S.read();
}

ESP32 I2S RMT peripheral conflict FastLED DMA interference

@ewowi, Great questions! Let me address each sensor type and the I2S/FastLED interference concern:

📌 1. MY-SR602 PIR Sensor (Passive Infrared Motion Detector)

No bus protocol needed – it's just a digital GPIO input!

The MY-SR602 is a simple digital motion sensor that outputs:

• HIGH (3.3V) when motion is detected
• LOW (0V) when no motion

Implementation in ModuleIO.h

Add a new pin usage type:

// In ModuleIO.h pin usage enum:
enum PinUsage {
  // ... existing types ...
  pin_PIR,        // NEW: Passive Infrared Motion sensor
  // ... rest of types ...
};

Add to UI dropdown:

// In setupDefinition():
addControlValue(control, "PIR");

No centralized management needed – each PIR driver node will just read its assigned GPIO pin directly using digitalRead().

Create a PIR Driver Node

Create src/MoonLight/Nodes/Drivers/D_PIR.h:

`#if` FT_MOONLIGHT

class PIRDriver : public Node {
 public:
  static const char* name() { return "PIR Sensor"; }
  static uint8_t dim() { return _NoD; }
  static const char* tags() { return "👁️"; }

  bool motionDetected = false;
  bool lastState = false;
  uint8_t pinPIR = UINT8_MAX;
  uint32_t lastTriggerTime = 0;
  uint32_t cooldownMs = 2000;  // Configurable cooldown period

  void setup() override {
    addControl(motionDetected, "motion", "checkbox", 0, 1, true);  // read-only
    addControl(cooldownMs, "cooldown", "number", 100, 60000, false, "ms");
  }

  void onUpdate(const Char<20>& oldValue, const JsonObject& control) override {
    if (!control["on"].isNull()) {
      if (control["on"] == true) {
        // Find PIR pin from ModuleIO
        pinPIR = UINT8_MAX;
        for (JsonObject pinObject : modules->getModuleOfClass<ModuleIO>()->_state.data["pins"].as<JsonArray>()) {
          if (pinObject["usage"] == pin_PIR) {
            pinPIR = pinObject["GPIO"];
            break;
          }
        }
        
        if (pinPIR != UINT8_MAX) {
          pinMode(pinPIR, INPUT);
          EXT_LOGI(ML_TAG, "PIR sensor initialized on GPIO %d", pinPIR);
        } else {
          EXT_LOGW(ML_TAG, "No PIR pin assigned in IO configuration");
        }
      }
    }
  }

  void loop() override {
    if (pinPIR == UINT8_MAX) return;
    
    bool currentState = digitalRead(pinPIR);
    
    // Detect rising edge (motion started)
    if (currentState && !lastState) {
      motionDetected = true;
      lastTriggerTime = millis();
      
      // Update shared data or trigger effects
      // sharedData.pirTriggered = true;  // If you add this field to SharedData
      
      // Update UI
      JsonDocument doc;
      doc["motion"] = true;
      update(doc.as<JsonObject>(), ModuleState::update, _nodeName);
      
      EXT_LOGI(ML_TAG, "Motion detected!");
    }
    
    // Auto-reset after cooldown
    if (motionDetected && (millis() - lastTriggerTime > cooldownMs)) {
      motionDetected = false;
      
      JsonDocument doc;
      doc["motion"] = false;
      update(doc.as<JsonObject>(), ModuleState::update, _nodeName);
    }
    
    lastState = currentState;
  }
};

`#endif`

Register in ModuleDrivers.h:

addControlValue(control, getNameAndTags<PIRDriver>());
// ...
if (!node) node = checkAndAlloc<PIRDriver>(name);

📌 2. I2S Microphones (INMP441, ICS-43432/4)

Yes, centralize I2S bus management in ModuleIO.h (similar to I2C/SPI)

I2S microphones use the I2S bus protocol with these signals:

• SD (Serial Data / DOUT from mic → DIN to ESP32)
• WS (Word Select / LRCLK - left/right channel clock)
• SCK (Bit Clock / BCLK)
• MCLK (Master Clock - optional, some mics don't need it)

ModuleIO.h already has I2S pin types defined!

Looking at the code, ModuleIO.h already includes:

pin_I2S_SD,
pin_I2S_WS,
pin_I2S_SCK,
pin_I2S_MCLK,

And some board presets already assign them (e.g., board_SR for SR boards with mic support).

Add I2S Bus Initialization to ModuleIO.h

Similar to the I2C centralization, add I2S management:

// In ModuleIO.h, add includes at top:
`#include` <I2S.h>

// In setupDefinition():
addControl(controls, "i2sFreq", "number", 0, 96000, false, "Hz");  // Sample rate

control = addControl(controls, "i2sBus", "rows");
control["crud"] = "r";
rows = control["n"].to<JsonArray>();
{
  addControl(rows, "device", "text", 0, 32, true);  // ro - device type
  addControl(rows, "active", "checkbox", 0, 1, true);  // ro - is initialized
}

// Private members:
uint8_t pinI2SSD = UINT8_MAX;
uint8_t pinI2SWS = UINT8_MAX;
uint8_t pinI2SSCK = UINT8_MAX;
uint8_t pinI2SMCLK = UINT8_MAX;
bool i2sInitialized = false;

// Public methods:
bool isI2SInitialized() const { return i2sInitialized; }

Extend readPins() to initialize I2S:

void readPins() {
  // ... existing I2C code ...
  
  // I2S pin detection
  for (JsonObject pinObject : _state.data["pins"].as<JsonArray>()) {
    uint8_t usage = pinObject["usage"];
    if (usage == pin_I2S_SD) {
      pinI2SSD = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "I2S SD found %d", pinI2SSD);
    }
    if (usage == pin_I2S_WS) {
      pinI2SWS = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "I2S WS found %d", pinI2SWS);
    }
    if (usage == pin_I2S_SCK) {
      pinI2SSCK = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "I2S SCK found %d", pinI2SSCK);
    }
    if (usage == pin_I2S_MCLK) {
      pinI2SMCLK = pinObject["GPIO"];
      EXT_LOGD(ML_TAG, "I2S MCLK found %d", pinI2SMCLK);
    }
  }
  
  // Initialize I2S if all required pins are assigned
  if (pinI2SSD != UINT8_MAX && pinI2SWS != UINT8_MAX && pinI2SSCK != UINT8_MAX) {
    I2S.end();  // Clean up any previous I2S initialization
    
    // setPins(bclk, ws, dout, din, mclk)
    // For microphone: dout=-1 (we're not outputting), din=SD pin
    int8_t mclkPin = (pinI2SMCLK != UINT8_MAX) ? pinI2SMCLK : -1;
    I2S.setPins(pinI2SSCK, pinI2SWS, -1, pinI2SSD, mclkPin);
    
    uint32_t sampleRate = _state.data["i2sFreq"] | 16000;  // Default 16kHz
    
    // Begin in standard mode, 16-bit samples, mono (microphone)
    bool success = I2S.begin(I2S_MODE_STD, sampleRate, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO);
    
    if (success) {
      i2sInitialized = true;
      EXT_LOGI(ML_TAG, "I2S bus initialized: sd:%d ws:%d sck:%d mclk:%d @ %d Hz", 
               pinI2SSD, pinI2SWS, pinI2SSCK, pinI2SMCLK, sampleRate);
      
      updateI2SDevices();
    } else {
      EXT_LOGW(ML_TAG, "I2S initialization failed");
    }
  }
}

void updateI2SDevices() {
  JsonDocument doc;
  doc["i2sBus"].to<JsonArray>();
  JsonObject newState = doc.as<JsonObject>();
  
  if (i2sInitialized) {
    JsonObject device = newState["i2sBus"].as<JsonArray>().add<JsonObject>();
    device["device"] = "I2S Microphone";
    device["active"] = true;
  }
  
  doc["i2sFreq"] = _state.data["i2sFreq"] | 16000;
  update(newState, ModuleState::update, _moduleName);
}

Create a Microphone Driver Node

Create src/MoonLight/Nodes/Drivers/D_Microphone.h:

`#if` FT_MOONLIGHT

`#include` <I2S.h>

class MicrophoneDriver : public Node {
 public:
  static const char* name() { return "Microphone"; }
  static uint8_t dim() { return _NoD; }
  static const char* tags() { return "🎤"; }

  uint16_t volumeLevel = 0;      // Current volume (0-1023)
  uint16_t volumePeak = 0;       // Peak volume
  uint16_t volumeAverage = 0;    // Running average
  bool soundDetected = false;
  uint16_t threshold = 100;      // Configurable threshold

  void setup() override {
    addControl(volumeLevel, "volume", "number", 0, 1023, true);      // read-only
    addControl(volumePeak, "peak", "number", 0, 1023, true);         // read-only
    addControl(volumeAverage, "average", "number", 0, 1023, true);   // read-only
    addControl(soundDetected, "sound", "checkbox", 0, 1, true);      // read-only
    addControl(threshold, "threshold", "number", 0, 1023, false);
  }

  void onUpdate(const Char<20>& oldValue, const JsonObject& control) override {
    if (!control["on"].isNull()) {
      if (control["on"] == true) {
        ModuleIO* io = modules->getModuleOfClass<ModuleIO>();
        if (io && io->isI2SInitialized()) {
          EXT_LOGI(ML_TAG, "Microphone driver activated");
        } else {
          EXT_LOGW(ML_TAG, "I2S not initialized by ModuleIO");
        }
      }
    }
  }

  void loop20ms() override {
    ModuleIO* io = modules->getModuleOfClass<ModuleIO>();
    if (!io || !io->isI2SInitialized()) return;
    
    // Read I2S samples
    int32_t sample = I2S.read();
    
    // Convert to absolute value and scale
    uint16_t magnitude = abs(sample) >> 16;  // Adjust scaling as needed
    
    volumeLevel = magnitude;
    
    // Update peak
    if (magnitude > volumePeak) {
      volumePeak = magnitude;
    } else {
      volumePeak = (volumePeak * 15 + magnitude) / 16;  // Slow decay
    }
    
    // Update running average
    volumeAverage = (volumeAverage * 15 + magnitude) / 16;
    
    // Sound detection
    soundDetected = (magnitude > threshold);
    
    // Store in shared data for effects to use
    // sharedData.audioLevel = volumeLevel;  // If you add this to SharedData
    
    // Update UI periodically (not every 20ms to avoid spam)
    static uint8_t updateCounter = 0;
    if (++updateCounter >= 25) {  // Update UI every 500ms
      updateCounter = 0;
      JsonDocument doc;
      doc["volume"] = volumeLevel;
      doc["peak"] = volumePeak;
      doc["average"] = volumeAverage;
      doc["sound"] = soundDetected;
      update(doc.as<JsonObject>(), ModuleState::update, _nodeName);
    }
  }
};

`#endif`

📌 3. Do I2S Microphones Interfere with I2S FastLED Drivers?

✅ Good news: NO direct conflict!

Why:

1. FastLED uses RMT, not I2S (on modern ESP-IDF 5.x / Arduino-ESP32 3.x)

   • From your learning: "FastLED defaults to RMT5 driver (wraps Espressif's led_strip component)"
   • Your platformio.ini can force RMT4: -D FASTLED_RMT5=0

2. RMT and I2S are different peripherals

   • RMT = Remote Control Transceiver (generates precise timing pulses for WS2812/SK6812 LEDs)
   • I2S = Inter-IC Sound (serial audio interface for microphones/speakers)
   • They use different hardware blocks on the ESP32

3. The "I2S" in your D_FastLED.h is OLD/DEPRECATED

   • The FASTLED_USES_ESP32S3_I2S flag refers to FastLED's legacy I2S LCD parallel mode
   • This mode is not compatible with ESP-IDF 5.x and should not be used
   • Your code correctly shows bool usesI2S = false for modern builds

⚠️ Potential indirect issues (DMA bandwidth competition)

While RMT and I2S won't directly conflict, both are DMA-based, so:

Possible symptoms if both are heavily used:

• LED timing glitches (sparkles/junk pixels)
• Audio dropouts
• Increased CPU load from DMA buffer management

Mitigations:

1. Allocate DMA buffers in internal RAM (not PSRAM):

   buffer = (uint8_t*)heap_caps_malloc(size, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);

2. Avoid flash operations during critical timing (especially during FastLED.show()):

   • Don't read SPIFFS/LittleFS
   • Minimize logging
   • Avoid heavy WiFi activity

3. Pin FastLED and audio processing to different cores:

   // FastLED on Core 1 (APP_CPU)
   xTaskCreatePinnedToCore(ledTask, "LED", 4096, NULL, 1, NULL, 1);
   
   // Audio on Core 0 (PRO_CPU)
   xTaskCreatePinnedToCore(audioTask, "Audio", 4096, NULL, 1, NULL, 0);

4. Reduce I2S sample rate if not needed:

   • Use 16kHz instead of 44.1kHz if acceptable for your use case
   • Lower rates = less DMA traffic

Summary Table:

📋 Action Items Summary

For PIR Sensors:

1. ✅ Add pin_PIR usage type to ModuleIO.h
2. ✅ Create D_PIR.h driver (simple GPIO input reading)
3. ✅ Register in ModuleDrivers.h

For I2S Microphones:

1. ✅ Centralize I2S bus management in ModuleIO.h (similar to I2C/SPI)
2. ✅ Initialize I2S bus when pins are assigned
3. ✅ Create D_Microphone.h driver
4. ✅ Add audio level to SharedData for effects to use
5. ✅ Consider adding FFT analysis if you want frequency-reactive effects

Interference Mitigation:

1. ✅ Verify you're using FastLED RMT mode (not I2S LCD mode)
2. ✅ Allocate DMA buffers in internal RAM
3. ✅ Minimize flash/WiFi activity during LED updates
4. ✅ Consider dual-core task pinning for heavy loads

Would you like me to generate the complete implementation code for either the PIR driver or the I2S microphone driver?

Learnt from: ewowi
Repo: MoonModules/MoonLight PR: 0
File: :0-0
Timestamp: 2026-01-26T14:59:22.091Z
Learning: In MoonModules/MoonLight PR `#114`: ModuleDevices deadlock caused by: (1) StatefulService.h line 204-205 bug - after 500ms mutex timeout, continues WITHOUT acquiring mutex, causing race conditions and JSON corruption. (2) receiveUDP() while-loop processes own UDP broadcasts via loopback, creating circular call chain: sendUDP→broadcast→receiveUDP→updateDevices→update→handlers→sendUDP. (3) updateDevices() holds _accessMutex during expensive sort/JSON operations with 15 devices, can exceed 500ms with nested calls. Solution: Fix StatefulService to wait forever or reboot on timeout; skip own broadcasts by checking message.name == ownHostname; optimize updateDevices to sort outside mutex.

Learnt from: ewowi
Repo: MoonModules/MoonLight PR: 0
File: :0-0
Timestamp: 2026-02-05T13:20:45.988Z
Learning: In MoonLight with FastLED 3.11 on ESP-IDF 5.x+ (Arduino core 3.x): FastLED defaults to RMT5 driver (wraps Espressif's led_strip component), which has known ISR handler lifecycle issues causing repeated "Handler detached" messages every ~500ms and severe performance degradation (e.g., 2 FPS). RMT5 is more prone to Wi-Fi/interrupt jitter than legacy RMT4. Solution: force legacy RMT4 by adding `-D FASTLED_RMT5=0` to build flags in platformio.ini, or switch to FastLED's parallel I/O drivers which don't use RMT. RMT4 and RMT5 cannot coexist in the same binary.